home *** CD-ROM | disk | FTP | other *** search
/ STraTOS 1997 April & May / STraTOS 1 - 1997 April & May.iso / CD01 / PRGMANIA / QEDSRC / GLOBAL.C < prev    next >
Encoding:
C/C++ Source or Header  |  1997-01-14  |  22.6 KB  |  1,015 lines
  1. #include "global.h"
  2. #include "fontsel.h"
  3. #include "fsel.h"
  4. #include "magx.h"
  5. #include "mintlib.h"
  6. #include "obj.h"
  7. #include "rsc.h"
  8. #include "scroll.h"
  9. #include "set.h"
  10.  
  11. /*
  12.  * exportierte Variablen
  13.  */
  14. GLOBAL WORD        phys_handle;        /* Physikalisches Workstation Handle */
  15. GLOBAL WORD        gl_apid;                /* Identifikation für Applikation */
  16. GLOBAL WORD        gl_wchar;            /* Je nach aktuellem Font z.B. 8*16 */
  17. GLOBAL WORD        gl_hchar;
  18. GLOBAL WORD        sys_wchar;            /* 8*16 */
  19. GLOBAL WORD        sys_hchar;
  20. GLOBAL WORD        sys_wbox;            /* 19*19 */
  21. GLOBAL WORD        sys_hbox;
  22. GLOBAL WORD        min_ascii;
  23. GLOBAL WORD        max_ascii;
  24.  
  25. GLOBAL WORD        fill_color;            /* aktuell eingestellte Füllfarbe */
  26. GLOBAL WORD        planes;                /* Anzahl der Planes */
  27. GLOBAL WORD        gem;                    /* GEM-Version */
  28. GLOBAL BOOLEAN    mint;                    /* MiNT aktiv? */
  29. GLOBAL BOOLEAN    aes41;                /* MultiTOS aktiv? */
  30. GLOBAL WORD        magx;                    /* Mag!X da */
  31. GLOBAL BOOLEAN    gdos;                    /* GDOS vorhanden? */
  32.  
  33. GLOBAL BOOLEAN    global_shift;        /* bei aktueller Opertion wurde Shift gedrückt */
  34. GLOBAL BOOLEAN    quick_close;        /* Sichern der Texte ohne Nachfrage */
  35. GLOBAL WORD        vdi_handle;            /* Virtuelles Workstation Handle */
  36.  
  37. GLOBAL RECT        desk;                    /* Bildschirm-Grö₧e  z.B. 0, 19, 640, 381 */
  38.  
  39. GLOBAL BOOLEAN    done;                    /* Ende gewählt ? */
  40. GLOBAL PATH        qed_path;            /* Name und Pfad der qed-Datei */
  41. GLOBAL PATH        app_path;            /* Pfad der Applikation */
  42. GLOBAL PATH        scrapdir;            /* Clipboard-Pfad */
  43.  
  44. GLOBAL struct tm    *local_time;    /* enthält die aktuelle Uhrzeit */
  45.  
  46. GLOBAL WORD        desire_x, return_code;
  47. GLOBAL LONG        desire_y, undo_y;
  48.  
  49. /****** DEFINES **************************************************************/
  50.  
  51. #define CTRL_CHAR     '^'        /* Menü-Control-Buchstabe */
  52. #define ALT_CHAR        0x07        /* Menü-Alternate-Buchstabe */
  53.  
  54. #define MFILE_ANZ        10            /* Anzahl für Selectric & Komp. */
  55.  
  56. /****** TYPES ****************************************************************/
  57.  
  58. /****** VARIABLES ************************************************************/
  59.  
  60. LOCAL WORD        hidden = 0;
  61. LOCAL WORD        act_mousenumber    = 0;
  62. LOCAL WORD        last_mousenumber = 0;
  63. LOCAL BOOLEAN     sleep = FALSE;
  64.  
  65. LOCAL RECT         clip;         /* Letztes Clipping Rechteck */
  66. LOCAL BOOLEAN     clip_flag;
  67.  
  68. LOCAL BOOLEAN     ext_fsel;        /* erweitertes Fileselect-Box möglich */
  69.  
  70. LOCAL PATH         fs_path;         /* Pfad der Dateiauswahl-Box */
  71. LOCAL FSEL         default_fsel;    /* Suffix und Name in Box */
  72.  
  73. LOCAL UBYTE        *slct_files[MFILE_ANZ];
  74. LOCAL LONG        _idt;                            /* Cookie für Datum und Zeit */
  75.  
  76. /****** FUNCTIONS ************************************************************/
  77.  
  78. /*****************************************************************************/
  79. /* Öffne virtuelle Workstation                                                                                             */
  80. /*****************************************************************************/
  81.  
  82. WORD open_vwork (WORD *w_out)
  83. {
  84.     WORD    i, handle;
  85.     WORD    work_in[11];
  86.  
  87.     for (i = 0; i < 11; i++)
  88.         work_in[i] = 1;
  89.     work_in[5]    = 0;
  90.     work_in[9]    = WHITE;                     /* Füllfarbe */
  91.     work_in[10] = RC;                         /* Raster Koordinaten */
  92.     handle = phys_handle;
  93.     v_opnvwk (work_in, &handle, w_out); /* Öffne virtuelle Workstation */
  94.     return (handle);
  95. }
  96.  
  97. /*****************************************************************************/
  98. /* Maus-Routinen                                                                                                                         */
  99. /*****************************************************************************/
  100.  
  101. VOID Set_mouse (WORD number)
  102. {
  103.     last_mousenumber    = act_mousenumber;
  104.     act_mousenumber    = number;
  105.     Wake_mouse();
  106.     graf_mouse (number, NULL);
  107.     sleep = FALSE;
  108. }
  109.  
  110. WORD Get_mouse(VOID)
  111. {
  112.     return act_mousenumber;
  113. }
  114.  
  115. BOOLEAN Mouse_sleeps(VOID)
  116. {
  117.     return sleep;
  118. }
  119.  
  120. VOID Sleep_mouse (VOID)
  121. {
  122.     if (!sleep)
  123.     {
  124.         sleep = TRUE;
  125.         if (hidden==0) graf_mouse (M_OFF, NULL);
  126.     }
  127. }
  128.  
  129. VOID Wake_mouse (VOID)
  130. {
  131.     if (sleep)
  132.     {
  133.         sleep = FALSE;
  134.         if (hidden==0) graf_mouse (M_ON, NULL);
  135.     }
  136. }
  137.  
  138. VOID Last_mouse (VOID)
  139. {
  140.     Set_mouse (last_mousenumber);
  141. }
  142.  
  143. VOID Hide_mouse ()
  144. {
  145.     if (hidden==0 && !sleep) graf_mouse (M_OFF, NULL);
  146.     hidden++;
  147. }
  148.  
  149. VOID Show_mouse ()
  150. {
  151.     if (--hidden==0 && !sleep) graf_mouse (M_ON, NULL);
  152. }
  153.  
  154. VOID Busy_mouse ()
  155. {
  156.     Set_mouse (HOURGLASS);
  157. }
  158.  
  159. VOID Arrow_mouse ()
  160. {
  161.     Set_mouse (ARROW);
  162. }
  163.  
  164. /*****************************************************************************/
  165.  
  166. /* Ausgabe recht oben im Menü */
  167. VOID print_headline(UBYTE *str)
  168. {
  169.     WORD ret, len, width;
  170.  
  171.     set_clip(FALSE, NULL);
  172.     vst_font (vdi_handle, sys_font_id);                    /* Systemfont */
  173.     vst_point (vdi_handle, sys_font_size, &ret, &ret, &width, &ret);
  174.     len = (short) strlen(str);
  175.     v_gtext(vdi_handle, desk.w-len * width, 0, str);
  176.     vst_font (vdi_handle, winFont.ID);
  177.     vst_point (vdi_handle, winFont.Size, &ret, &ret, &ret, &ret);
  178. }
  179.  
  180.  
  181. /*****************************************************************************/
  182. LOCAL LONG        maxvalue;
  183. LOCAL    DIALINFO    aktion_box;
  184.  
  185. VOID start_aktion(const UBYTE *head, BOOLEAN inter, LONG max_value)
  186. {
  187.     maxvalue = max(max_value, 1);
  188.     fill_ptext(aktion, ATEXT, head);
  189.     aktion[ABOX2].ob_width = 1;
  190.     hide_objc(aktion, AESC, !inter);
  191.     open_dial(aktion, TRUE, NULL, &aktion_box);
  192.     dial_draw(&aktion_box);
  193. }
  194.  
  195. VOID do_aktion (LONG value)
  196. {
  197.     LONG max_len, help;
  198.  
  199.     max_len = aktion[ABOX1].ob_width;
  200.     help = max((max_len * value) / maxvalue,1);
  201.     help = min(max_len, help);
  202.     if (aktion[ABOX2].ob_width != help)
  203.     {
  204.         aktion[ABOX2].ob_width = (short) help;
  205.         draw_Objc(aktion, ABOX2, 1);
  206.     }
  207. }
  208.  
  209. VOID end_aktion (VOID)
  210. {
  211.     dial_end(&aktion_box);
  212. }
  213.  
  214. /*****************************************************************************/
  215.  
  216. VOID str_upper(UBYTE *str)
  217. {
  218.     while (*str != EOS)
  219.     {
  220.         *str = nkc_toupper(*str);
  221.         str++;
  222.     }
  223. }
  224.  
  225. VOID str_lower(UBYTE *str)
  226. {
  227.     while (*str != EOS)
  228.     {
  229.         *str = nkc_tolower(*str);
  230.         str++;
  231.     }
  232. }
  233.  
  234. /*****************************************************************************/
  235.  
  236. BOOLEAN str_to_key(UBYTE *str, MKINFO *mk)
  237. {
  238.     UBYTE    c, sign, *s1, *s2;
  239.     BOOLEAN    erg = FALSE;
  240.  
  241.     if ((str[0] == EOS) || (mk == NULL))
  242.         return FALSE;
  243.  
  244.     s1 = strrchr(str, CTRL_CHAR);
  245.     s2 = strrchr(str, ALT_CHAR);
  246.     if (s1 > s2)
  247.         str = s1;
  248.     else
  249.         str = s2;
  250.  
  251.     if (str!=NULL && strlen(str)>=2)         /* Sign und Buchstabe */
  252.     {
  253.         sign = *str++;                             /* "Vorzeichen" */
  254.         c      = *str;                                /* Eigentliches Zeichen */
  255.         switch (sign)
  256.         {
  257.         case CTRL_CHAR:
  258.             mk->kstate = K_CTRL;
  259.             mk->kreturn = NKF_FUNC|NKF_CTRL|c;
  260.             mk->ascii_code = c;
  261.             mk->scan_code = 0;
  262.             mk->shift = FALSE;
  263.             mk->ctrl = TRUE;
  264.             mk->alt = FALSE;
  265.             erg = TRUE;
  266.             break;
  267.         case ALT_CHAR:
  268.             mk->kstate = K_ALT;
  269.             mk->kreturn = NKF_FUNC|NKF_ALT|c;
  270.             mk->ascii_code = c;
  271.             mk->scan_code = 0;
  272.             mk->shift = FALSE;
  273.             mk->ctrl = FALSE;
  274.             mk->alt = TRUE;
  275.             erg = TRUE;
  276.             break;
  277.         }
  278.     }
  279.     return erg;
  280. }
  281.  
  282. /*****************************************************************************/
  283.  
  284. BOOLEAN inside (WORD x, WORD y, const RECT *r)
  285. {
  286.     return (x>=r->x && y>=r->y && x<r->x+r->w && y<r->y+r->h);
  287. } /* inside */
  288.  
  289. /*****************************************************************************/
  290.  
  291. BOOLEAN get_clip (RECT *size)
  292. {
  293.     *size = clip;
  294.     return clip_flag;
  295. }
  296.  
  297. VOID set_clip (BOOLEAN clipflag, const RECT *size)
  298. {
  299.     WORD    xy[4];
  300.  
  301.     if (!clip_flag && !clipflag) return;    /* Es ist aus und bleibt aus */
  302.     clip_flag = clipflag;
  303.     if (clipflag)
  304.     {
  305.         if (size == NULL)
  306.             clip = desk;                            /* Nichts definiert, nimm Desktop */
  307.         else
  308.         {
  309.             clip = *size;                            /* Benutze definierte Grö₧e */
  310.             if (!myrc_intersect (&desk, &clip))/* Nur auf Desktop zeichnen */
  311.             {
  312.                 clip.x = 0;                         /* Nichts zeichnen */
  313.                 clip.y = 0;
  314.                 clip.w = 0;
  315.                 clip.h = 0;
  316.             }
  317.         }
  318.         rect2array(&clip,xy);
  319.     }
  320.     else
  321.         clip = desk;
  322.     vs_clip (vdi_handle, clipflag, xy);     /* Setze Rechteckausschnitt */
  323. } /* set_clip */
  324.  
  325.  
  326. /*****************************************************************************/
  327.  
  328. WORD note (WORD button, WORD index)
  329. {
  330.     WORD ret;
  331.  
  332.     Arrow_mouse ();
  333.     ret = do_alert(button, (BYTE *)alertmsg[index]);
  334.     Last_mouse ();
  335.     return (ret);
  336. } /* note */
  337.  
  338. /*****************************************************************************/
  339.  
  340. WORD inote(WORD button, WORD index, LONG i)
  341. {
  342.     UBYTE str[20];
  343.  
  344.     ltoa(i,str,10);
  345.     return snote(button,index,str);
  346. }
  347.  
  348. /*****************************************************************************/
  349.  
  350. WORD snote (WORD button, WORD index, UBYTE *str)
  351. {
  352.     WORD    ret, len;
  353.     UBYTE    s[200], *ptr;
  354.  
  355.     len = (short) strlen(str);
  356.     strcpy(s, alertmsg[index]);
  357.     ptr = strchr(s,'$');
  358.     if (ptr!=NULL)
  359.     {
  360.         MOVE(ptr+len, ptr+1, (short) strlen(ptr));
  361.         COPYB(ptr,str,len);
  362.     }
  363.     Arrow_mouse ();
  364.     ret = do_alert (button, (BYTE *)s);
  365.     Last_mouse ();
  366.     return (ret);
  367. } /* inote */
  368.  
  369. /***************************************************************************/
  370. /* Verschiedenes                                                                                */
  371. /***************************************************************************/
  372.  
  373. VOID make_shortpath(const UBYTE *path, UBYTE *shortpath, WORD maxlen)
  374. {
  375.     PATH    help;
  376.     WORD    path_len;
  377.     UBYTE    *p1, *p2;
  378.  
  379.     strcpy(help,path);
  380.     path_len = (short) strlen(help);
  381.     if (maxlen < 18)
  382.     {
  383.         file_name(path,help, FALSE);
  384.     }
  385.     else if (path_len>maxlen)
  386.     {
  387.         p1 = strchr(help,'\\');
  388.         p2 = p1;
  389.         path_len += 2;     /* zwei Punkte neu */
  390.         while(*p2!=EOS && path_len>maxlen)
  391.         {
  392.             p2++;
  393.             while(*p2!='\\' && *p2!=EOS)
  394.             {
  395.                 p2++;
  396.                 path_len--;
  397.             }
  398.         }
  399.         if (*p2!=EOS)
  400.         {
  401.             MOVE(p1+3, p2, (short)strlen(p2)+1);
  402.             p1[1] = '.';
  403.             p1[2] = '.';
  404.         }
  405.         else
  406.         {
  407.             p2 = strrchr(help,'\\');
  408.             MOVE(help, p2, (short)strlen(p2)+1);
  409.         }
  410.     }
  411.     strcpy(shortpath,help);
  412. }
  413.  
  414. /* Macht aus allem einen kompletten Pfad            */
  415. /* evtl. vorhandene Dateinamen bleiben erhalten */
  416. /* with_filename = hat ganz sicher Dateinamen    */
  417. BOOLEAN make_normalpath(UBYTE *path, BOOLEAN with_filename)
  418. {
  419.     WORD    i;
  420.     PATH    p;
  421.     UBYTE    *f, drv;
  422.  
  423.     if (path[0] == EOS)
  424.         return FALSE;
  425.  
  426.     if (path[0] == '/')                /* UNIX-Pfad */
  427.         unx2dos(path);
  428.  
  429.     /* Laufwerk bestimmen */
  430.     if (path[1] != ':')                 /* Kein Laufwerk */
  431.     {
  432.         drv = 'A' + Dgetdrv();        /* aktuelles Laufwerk */
  433.         if (drv > 'Z')
  434.             drv = drv - 'Z' + '0';    /* A..Z 1..6 */
  435.         f = path;
  436.     }
  437.     else
  438.     {
  439.         path[0] = nkc_toupper(path[0]);
  440.          drv = path[0];
  441.         if (drv > 'Z')
  442.             drv = drv - 'Z' + '0';    /* A..Z 1..6 */
  443.          f = path + 2;
  444.     }
  445.     /* Pfad mit Laufwerk bestimmen */
  446.     if (f[0]=='.' && (f[1]=='\\' || f[1]==EOS))
  447.     {
  448.         get_path(p, drv);         /* aktuellen Pfad nehmen */
  449.         if (f[1]=='\\') strcat(p,f+2);
  450.     }
  451.     else if (f[0]!='\\')             /* Keine Root */
  452.     {
  453.         get_path(p, drv);
  454.         strcat (p, f);
  455.     }
  456.     else
  457.     {
  458.         p[0] = drv;
  459.         p[1] = ':';
  460.         p[2] = EOS;
  461.         strcat (p, f);
  462.     }
  463.     if (!with_filename)            /* herausbekommen ob Dateiname */
  464.     {
  465.         i = (short) strlen(p);
  466.         if (p[i-1]!='\\')
  467.         {
  468.             p[i] = '\\';
  469.             p[i+1] = EOS;
  470.         }
  471.         if (!path_exist(p))
  472.             p[i] = EOS;
  473.     }
  474.     strcpy(path,p);
  475.     return TRUE;
  476. } /* make_normalpath */
  477.  
  478. VOID make_ext(UBYTE *fullname, const UBYTE *ext)
  479. {
  480.     UBYTE    *ptr;
  481.  
  482.     ptr = strrchr(fullname,'.');
  483.     if (ptr == NULL || ptr < strrchr(fullname,'\\'))
  484.     {
  485.         ptr = fullname + strlen(fullname);
  486.         *ptr = '.';
  487.     }
  488.     if (caseSens(fullname, NULL))
  489.         strcpy(ptr+1, ext);
  490.     else
  491.     {
  492.         UBYTE    myext[5];
  493.  
  494.         strcpy(myext, ext);
  495.         str_upper(myext);
  496.         strcpy(ptr+1, myext);
  497.     }
  498. }
  499.  
  500. VOID file_name(const UBYTE *fullname, UBYTE *filename, BOOLEAN withoutExt)
  501. {
  502.     file_splitt(fullname, NULL, filename);
  503.     if (withoutExt)
  504.     {
  505.         UBYTE    *p;
  506.  
  507.         p = strrchr(filename, '.');
  508.         if (p != NULL)
  509.             *p = EOS;
  510.     }
  511. }
  512.  
  513. VOID file_splitt(const UBYTE *fullname, UBYTE *path, UBYTE *name)
  514. {
  515.     UBYTE     *str;
  516.  
  517.     str = strrchr (fullname, '\\');
  518.  
  519.     if (path != NULL)
  520.         path[0] = EOS;        /* schadet nix */
  521.     if (name != NULL)
  522.         name[0] = EOS;        /* ditto */
  523.  
  524.     if (str != NULL)
  525.     {
  526.         /* Dateinamen holen */
  527.         if (name != NULL)
  528.             strcpy(name, str+1);
  529.  
  530.         /* Pfad mit Laufwerk bestimmen */
  531.         if (path != NULL)
  532.         {
  533.             WORD len =  (short)( str - (UBYTE *)fullname + 1);
  534.             strncpy(path, fullname, len);
  535.             path[len] = EOS;
  536.         }
  537.     }
  538. } /* file_split */
  539.  
  540. /*****************************************************************************/
  541.  
  542. WORD get_first_drive(VOID)
  543. {
  544.     ULONG    drives;
  545.     WORD    drive;
  546.  
  547.     drives = Dsetdrv(Dgetdrv());                    /* Alle Laufwerke */
  548.     if (drives == 0)
  549.         drive = -1;
  550.     else if (drives <= 3)
  551.         drive = 0;                                        /* Benutze Laufwerk A */
  552.     else
  553.     {
  554.         drives >>= 2;
  555.         drive = 2;                                        /* Beginne bei Laufwerk C */
  556.         while (!(drives & 1) && drive < 32)    /* Laufwerk gefunden */
  557.         {
  558.             drive++;
  559.             drives >>= 1;
  560.         }
  561.     }
  562.     return drive;
  563. }
  564.  
  565. /*****************************************************************************/
  566.  
  567. VOID drive_name(WORD drive, UBYTE *name)
  568. {
  569.     UBYTE    n[]="A:\\*.*" ;
  570.     DTA    dta, *old_dta;
  571.  
  572.     old_dta = Fgetdta();
  573.     Fsetdta (&dta);
  574.     n[0] = 'A' + (drive - 1);
  575.     if (Fsfirst (n, FA_VOLUME) == 0)
  576.         strcpy(name, dta.d_fname);
  577.     else
  578.         name[0] = EOS;
  579.     Fsetdta (old_dta);
  580. }
  581.  
  582. /*****************************************************************************/
  583.  
  584. VOID get_drive_space(WORD drive, ULONG *total, ULONG *free)
  585. {
  586.     DISKINFO    info;
  587.     WORD        err;
  588.     ULONG        help;
  589.  
  590.     err = Dfree(&info, drive);
  591.     if (!err)
  592.     {
  593.         help = (info.b_secsiz * info.b_clsiz);
  594.         if (total != NULL)
  595.             *total = (info.b_total*help);                /* Byte */
  596.         if (free != NULL)
  597.             *free = (info.b_free * help);                /* Byte */
  598.     }
  599.     else
  600.     {
  601.         if (free != NULL)
  602.             *free = 0;
  603.         if (total != NULL)
  604.             *total = 0;
  605.     }
  606. }
  607.  
  608. /*****************************************************************************/
  609.  
  610. BOOLEAN get_path (UBYTE *path, UBYTE drive)
  611. {
  612.     WORD ret, drive_nr;
  613.  
  614.     if (drive == 0)
  615.     {
  616.         drive = 'A' + Dgetdrv();                    /* Aktuelles Laufwerk */
  617.         if (drive > 'Z')
  618.             drive = drive - 'Z' + '0';
  619.     }
  620.     else
  621.         drive = nkc_toupper(drive);
  622.     if (drive >= '1' && drive <= '6')            /* Laufwerk nach Z mit Big-DOS oder MetaDOS > 2.60 */
  623.         drive_nr = drive - '1' + 26;
  624.     else
  625.         drive_nr = drive - 'A';
  626.     path[0] = drive;
  627.     path[1] = ':';
  628.     ret = Dgetpath (path + 2, drive_nr + 1);
  629.     strcat (path, "\\");
  630.     return (ret == 0);
  631. } /* get_path */
  632.  
  633.  
  634. BOOLEAN set_path(UBYTE *path)
  635. {
  636.     WORD    drive, ret;
  637.  
  638.     if (path[0] == EOS)
  639.         return FALSE;
  640.  
  641.     path[0] = nkc_toupper(path[0]);
  642.     if (path[0] >= '1' && path[0] <= '6')
  643.         drive = path[0] - '1' + 26;
  644.     else
  645.         drive = path[0] - 'A';
  646.     Dsetdrv(drive);
  647.     ret = Dsetpath(path + 2);
  648.     return (ret == 0);
  649. }
  650.  
  651. /*****************************************************************************/
  652.  
  653. LOCAL VOID make_time(unsigned LONG ltime, UBYTE *date, UBYTE *time)
  654. {
  655.     WORD    year, month, day;
  656.  
  657.     if (time != NULL)
  658.     {
  659.         strcpy(time,"00:00:00");
  660.         time[6] += (((unsigned)ltime&31)*2) / 10;
  661.         time[7] += (((unsigned)ltime&31)*2) % 10;
  662.         ltime>>=5;
  663.         time[3] += ((unsigned)ltime&63) / 10;
  664.         time[4] += ((unsigned)ltime&63) % 10;
  665.         ltime>>=6;
  666.         time[0] += ((unsigned)ltime&31) / 10;
  667.         time[1] += ((unsigned)ltime&31) % 10;
  668.         ltime>>=5;
  669.     }
  670.     else
  671.         ltime>>=16;
  672.     if (date != NULL)
  673.     {
  674.         day = (unsigned)ltime & 31;
  675.         ltime >>= 5;
  676.         month = (unsigned)ltime & 15;
  677.         ltime >>= 4;
  678.         year = ((unsigned)ltime & 127) + 1980;
  679.         switch ((UWORD)_idt & 0xF00)                    /* Reihenfolge im Datum */
  680.         {
  681.             case 0x000:  /* MM/DD/YYYY */
  682.                 sprintf(date, "%02d%c%02d%c%d", month, (UBYTE)(_idt&0xFF), day, (UBYTE)(_idt&0xFF), year);
  683.                 break;
  684.             case 0x100:  /* DD.MM.YYYY */
  685.                 sprintf(date, "%02d%c%02d%c%d", day, (UBYTE)(_idt&0xFF), month, (UBYTE)(_idt&0xFF), year);
  686.                 break;
  687.             default:  /* YYYY-MM-DD */
  688.                 sprintf(date, "%d%c%02d%c%02d", year, (UBYTE)(_idt&0xFF), month, (UBYTE)(_idt&0xFF), day);
  689.                 break;
  690.         }
  691.     }
  692. }
  693.  
  694. /*****************************************************************************/
  695.  
  696. VOID get_datum(UBYTE *date)
  697. {
  698.     make_time(Gettime(),date,NULL);
  699. }
  700.  
  701. /*****************************************************************************/
  702.  
  703. LONG file_time(const UBYTE *filename, UBYTE *date, UBYTE *time)
  704. {
  705.     LONG    ltime, ret;
  706.     XATTR    attr;
  707.  
  708.     ret = Fxattr(0, (UBYTE *)filename, &attr);
  709.     if (ret == 0)
  710.     {
  711.          ltime = (LONG)(UWORD)attr.mtime + ((LONG)(UWORD)attr.mdate << 16);
  712.         make_time(ltime, date, time);
  713.     }
  714.     else
  715.     {
  716.         DTA    dta, *old_dta;
  717.  
  718.         old_dta = Fgetdta();
  719.         Fsetdta (&dta);
  720.         if (Fsfirst((UBYTE*)filename, 0x17) == 0)
  721.         {
  722.             ltime = (LONG)dta.d_time+((LONG)dta.d_date<<16);
  723.             make_time(ltime, date, time);
  724.         }
  725.         else
  726.         {
  727.             ltime = 0L;
  728.             if (date!=NULL)
  729.                 date[0] = EOS;
  730.             if (time!=NULL)
  731.                 time[0] = EOS;
  732.         }
  733.         Fsetdta (old_dta);
  734.     }
  735.     return ltime;
  736. }
  737.  
  738. /*****************************************************************************/
  739.  
  740. LONG file_size(const UBYTE *filename)
  741. {
  742.     LONG    size = 0L,
  743.             ret;
  744.     XATTR    attr;
  745.  
  746.     ret = Fxattr(0, (UBYTE *)filename, &attr);
  747.     if (ret == 0)
  748.         size = attr.size;
  749.     else
  750.     {
  751.         DTA    dta, *old_dta;
  752.  
  753.         old_dta = Fgetdta();
  754.         Fsetdta (&dta);
  755.         if (Fsfirst((UBYTE*)filename, 0x17) == 0)
  756.             size = (LONG)dta.d_length;
  757.         Fsetdta (old_dta);
  758.     }
  759.     return size;
  760. }
  761.  
  762. /*****************************************************************************/
  763.  
  764. BOOLEAN file_exist (const UBYTE *filename)
  765. {
  766.     XATTR    attr;
  767.     LONG    ret;
  768.  
  769.     ret = Fxattr(0, (UBYTE *)filename, &attr);
  770.     if (ret != 0)
  771.     {
  772.         DTA    dta, *old_dta;
  773.  
  774.         old_dta = (DTA *)Fgetdta ();
  775.         Fsetdta (&dta);
  776.         ret = Fsfirst ((UBYTE*)filename, 0x17);
  777.         Fsetdta (old_dta);
  778.     }
  779.     return (ret == 0);
  780. } /* file_exist */
  781.  
  782. /*****************************************************************************/
  783.  
  784. BOOLEAN file_readonly (const UBYTE *filename)
  785. {
  786.     BOOLEAN    result = FALSE;
  787.     XATTR        attr;
  788.     LONG        ret;
  789.  
  790.     ret = Fxattr(0, (UBYTE *)filename, &attr);
  791.     if (ret == 0)
  792.     {
  793.         WORD    uid, gid;
  794.  
  795.         uid = Pgetuid();
  796.         gid = Pgetgid();
  797.         if (uid != -32 && gid != -32)        /* gibts Pget[ug]id ? */
  798.         {
  799.             if (((uid == attr.uid) && ((attr.mode & S_IWUSR) != 0)) ||    /* Besitzer hat Schreibrecht */
  800.                ((gid == attr.gid) && ((attr.mode & S_IWGRP) != 0)) ||    /* Gruppe hat Schreibrecht */
  801.                 (((attr.mode & S_IWOTH) != 0))    ||                                /* Welt hat Schreibrecht */
  802.                 ((uid == 0) && ((attr.mode & S_IWUSR) != 0)))                /* root darf, wenn Owner darf */
  803.                 result = FALSE;
  804.             else
  805.                 result = TRUE;
  806.         }
  807.         else
  808.             result = ((attr.attr & FA_READONLY) != 0);
  809.     }
  810.     else
  811.     {
  812.         DTA    dta, *old_dta;
  813.  
  814.         old_dta = (DTA *)Fgetdta ();
  815.         Fsetdta (&dta);
  816.         result = (Fsfirst ((UBYTE*)filename, 0x00) == 0);
  817.         if (result)
  818.             result = (dta.d_attrib&FA_READONLY) != 0;
  819.         else
  820.             result = FALSE;
  821.         Fsetdta (old_dta);
  822.     }
  823.     return (result);
  824. } /* file_readonly */
  825.  
  826. /*****************************************************************************/
  827.  
  828. BOOLEAN path_exist(const UBYTE *pathname)
  829. {
  830.     BOOLEAN    result;
  831.     PATH    s;
  832.     WORD    l;
  833.  
  834.     if (pathname[0] == EOS)
  835.         return FALSE;
  836.  
  837.     strcpy (s, pathname);
  838.     l = (short) strlen (s)-1;
  839.     s[l] = EOS;
  840.     if (l==2 && s[1]==':')
  841.     {
  842.         return TRUE;
  843.     }
  844.     else
  845.     {
  846.         LONG    ret;
  847.  
  848.         ret = Dopendir(s, 0);
  849.         if (ret == -32)                    /* kein Dopendir */
  850.         {
  851.             DTA    dta, *old_dta;
  852.  
  853.             old_dta = (DTA *)Fgetdta ();
  854.             Fsetdta (&dta);
  855.             result = (Fsfirst (s, 0x10)==0 && (dta.d_attrib&0x10));
  856.             Fsetdta (old_dta);
  857.         }
  858.         else
  859.         {
  860.             result = ((ret & 0xff000000L) != 0xff000000L) ; /* 0xff im obersten Byte? */
  861.             if (result)
  862.                 Dclosedir(ret) ;
  863.         }
  864.         return (result);
  865.     }
  866. } /* path_exist */
  867.  
  868. /*****************************************************************************/
  869. /* Dateiauswahl                                                                                  */
  870. /*****************************************************************************/
  871.  
  872. VOID set_fsel_path(const UBYTE *path)
  873. {
  874.     PATH    p;
  875.  
  876.     file_splitt(path, p, NULL);
  877.     if (path_exist(p))
  878.         strcpy(fs_path, p);
  879. }
  880.  
  881. BOOLEAN select_file (FSEL *fsel, UBYTE *filename, const UBYTE *lable)
  882. {
  883.     WORD    button;
  884.     UBYTE    *p;
  885.     PATH    l_path;
  886.     FILENAME    l_name;
  887.  
  888.     if (fsel==NULL)
  889.         fsel = &default_fsel;
  890.  
  891.     strcpy(l_path, fs_path);
  892.  
  893.     p = strrchr (l_path, '\\');
  894.     strcpy((p+1), fsel->suffix);
  895.     strcpy(l_name, fsel->name);
  896.  
  897.     Wake_mouse();
  898. /*    wind_update(BEG_UPDATE);*/
  899. /*    wind_update(BEG_MCTRL);*/
  900.     if (ext_fsel || gem >= 0x140 && gem < 0x200 || gem >= 0x300)
  901.         fsel_exinput (l_path, l_name, &button, (UBYTE*)lable);
  902.     else
  903.         fsel_input (l_path, l_name, &button);
  904. /*    wind_update(END_MCTRL);*/
  905. /*    wind_update(END_UPDATE);*/
  906.     if (button != 0)
  907.     {
  908.         p = strrchr (l_path, '\\');
  909.         strcpy(fsel->suffix, (UBYTE *)p+1);
  910.         p[1] = EOS;
  911.         make_normalpath(l_path,FALSE);
  912.         strcpy(fsel->name, l_name);
  913.  
  914.         strcpy (filename, l_path);
  915.         strcat (filename, l_name);
  916.         if (!caseSens(filename, NULL))
  917.             str_upper(filename);
  918.         set_fsel_path(l_path);                        /* aktuellen Pfad im GEMDOS ändern */
  919.     }
  920.     else
  921.         filename[0] = EOS;                            /* Abbruch gedrückt */
  922.     return (*l_name && (button !=0) );
  923. } /* select_file */
  924.  
  925. /***************************************************************************/
  926.  
  927. UBYTE **select_mfile (FSEL *fsel, UBYTE *path, const UBYTE *lable, WORD *anz)
  928. {
  929.     BOOLEAN    slct;
  930.  
  931.     slct =  slct_morenames(CMD_FILES_OUT, MFILE_ANZ, slct_files);
  932.     if (select_file (fsel, path, lable))
  933.     {
  934.         if (slct)
  935.             *anz = slct_getnum();
  936.         else
  937.             *anz = 1;
  938.     }
  939.     else
  940.         *anz = 0;
  941.     return (*anz > 1) ? slct_files : NULL;
  942. }
  943.  
  944. /***************************************************************************/
  945. /* Initialisieren des Moduls                                                                */
  946. /***************************************************************************/
  947.  
  948. VOID init_global (VOID)
  949. {
  950.     WORD    work_out[57], i, f_anz;
  951.     WORD    work_outx[57];
  952.     WORD    ret;
  953.  
  954.     Arrow_mouse();
  955.     phys_handle = graf_handle (&sys_wchar, &sys_hchar, &sys_wbox, &sys_hbox);
  956.     wind_get (0, WF_WORKXYWH, &desk.x, &desk.y, &desk.w, &desk.h);
  957.  
  958.     gdos    = vq_gdos();                            /* GDOS vorhanden */
  959.     ext_fsel = fsel_check();                    /* erweiterte FselBox */
  960.     if (ext_fsel)
  961.     {
  962.         for (i = 0; i < MFILE_ANZ; i++)
  963.         {
  964.             slct_files[i] = (UBYTE *) Malloc(sizeof(PATH));
  965.             strcpy(slct_files[i], "");
  966.         }
  967.     }
  968.     done    = FALSE;
  969.  
  970.     default_fsel.name[0] = EOS;
  971.     strcpy(default_fsel.suffix,"*.*");
  972.     get_path(fs_path, 0);                            /* Aktuellen Pfad holen */
  973.     strcat (fs_path, "*.*");                        /* für FileselctBox */
  974.  
  975.     vdi_handle = open_vwork(work_out);
  976.     fill_color = WHITE;
  977.     clip_flag = TRUE;
  978.     vq_extnd (vdi_handle, FALSE, work_outx);    /* So, wg. Fehler im VDI */
  979.     f_anz = work_outx[10];
  980.     vq_extnd (vdi_handle, TRUE, work_outx);
  981.     planes = work_outx[4];
  982.  
  983.     if (gdos)
  984.         f_anz += vst_load_fonts (vdi_handle, 0);
  985.     vswr_mode(vdi_handle, MD_REPLACE);
  986.     vsl_color (vdi_handle, BLACK);
  987.     vsl_ends (vdi_handle, SQUARE, SQUARE);
  988.     vsl_width (vdi_handle, 1);
  989.     vst_alignment(vdi_handle, TA_LEFT, TA_TOP, &ret, &ret);
  990.  
  991.     get_systemfont(f_anz);
  992.  
  993.     if (!getcookie('_IDT', &_idt))                /* Format für Datum und Zeit */
  994.         _idt = 0x0000112E;                            /* DD.MM.YYYY HH:MM:SS */
  995.  
  996. } /* init_global */
  997.  
  998. /************************************************************************/
  999. /* Terminieren des Moduls                                                                */
  1000. /************************************************************************/
  1001.  
  1002. VOID term_global(VOID)
  1003. {
  1004.     if (ext_fsel)
  1005.     {
  1006.         WORD    i;
  1007.  
  1008.         for (i = 0; i < MFILE_ANZ; i++)
  1009.             Mfree(slct_files[i]);
  1010.     }
  1011.     if (gdos)
  1012.         vst_unload_fonts (vdi_handle, 0);
  1013.     v_clsvwk(vdi_handle);
  1014. }
  1015.